First-order function dispatch in a Java-like programming language

Glossary 185 Bibliography 186 Contents iv 1 Introduction 1.1. Goals and motivation Separation of concerns is an important concept in software development. Every software application consists of multiple concerns, examples are: what is to be computed, how the results are displayed, who is authorized to view the results, which data is logged, etc. Separation of these concerns allows a programmer to focus on a single concern, without having to consider everything at once [10]. During the software life cycle, concerns often evolve separately. Therefore, evolution scenarios are better supported when concerns are separated. To separate concerns, software is typically decomposed in separate parts, called modules [6]. These modules are integrated in a coherent program by using composition operators. Composition operators are the language mechanisms which let programmers compose behaviour and/or data, defined as separate entities. Examples of composition operators are: function application, inheritance, delegation, pointcut-advice mechanisms, composition filters, etc. Function application allows the invo-cation of functionality defined separately—as a function definition—by using a call statement. Inheritance and delegation allow addressing fields and methods defined separately—as part of a super class or delegatee. Depending on the situation, different composition operators are needed, but no language provides all possible relevant operators. When a language does not provide a composition operator with the desired compositional behaviour, workarounds have to be used by the programmer. That is, introducing new operators by writing glue code, for example as macros, libraries, frameworks or language extensions. Often, these newly introduced operators are only partially integrated with the language. Therefore, its use might require additional glue code to be written, of which an example is given in the next paragraph. Typically, such glue code solutions suffer from a lack of maintainability. As shown in [16], delegation is a composition operator that requires additional glue code when explicit language support is lacking. In object-oriented languages that do not support explicit delegation [25], similar functionality can be simulated by 1 Introduction 2 forwarding calls from one object to another. However, when forwarding a call in this way, the self or this object context changes from the object the call was originally sent to—the interface object—to the object to which the call is delegated. In contrast, in languages that support explicit delegation, the self context does not change when delegating an operation. This difference leads to the so-called self problem in languages that do not support explicit delegation [25]. That is, …